home *** CD-ROM | disk | FTP | other *** search
/ Whiteline: Alpha / Whiteline Alpha.iso / progtool / modula2 / hk_lib / def_mod / xstrings.def < prev    next >
Encoding:
Modula Definition  |  1994-09-22  |  10.8 KB  |  188 lines
  1. DEFINITION MODULE  XStrings;
  2.  
  3. (*****************************************************************************)
  4. (* In diesem Modul sind weiterfuehrende Prozeduren fuer den in "Strings"     *)
  5. (* definierten Stringtyp enthalten. Alles grundsaetzliche, was dort ueber    *)
  6. (* die Strings gesagt wurde, gilt auch fuer dieses Modul.                    *)
  7. (*___________________________________________________________________________*)
  8. (*  05-Dez-89 , Holger Kleinschmidt                                          *)
  9. (*****************************************************************************)
  10.  
  11. FROM  Chars    IMPORT  (* TYPE *)  CharConvert, CharClassTest;
  12. FROM  Strings  IMPORT  (* TYPE *)  CompareResult;
  13.  
  14. (*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*)
  15.  
  16.  
  17.  PROCEDURE  FillStr ((* EIN/ -- *)     fuellung : CHAR;
  18.                      (* EIN/ -- *)     anzahl   : CARDINAL;
  19.                      (* -- /AUS *) VAR string   : ARRAY OF CHAR );
  20.  
  21. (*-------------------------------------------------------------------------
  22.  | <string> bekommt die Laenge <anzahl> und ist vollstaendig mit <fuellung>|
  23.  | belegt. Ist <anzahl> gleich Null oder groesser als die maximal moegliche|
  24.  | Laenge, wird bis zum Feldende aufgefuellt.                              |
  25.   -------------------------------------------------------------------------*)
  26.  
  27.  
  28.  PROCEDURE  ConvertStr ((* EIN/ -- *)     quelle : ARRAY OF CHAR;
  29.                         (* EIN/ -- *)     convert: CharConvert;
  30.                         (* -- /AUS *) VAR ziel   : ARRAY OF CHAR;
  31.                         (* -- /AUS *) VAR vollst : BOOLEAN       );
  32.  
  33. (*-------------------------------------------------------------------------
  34.  | <quelle> wird zeichenweise mittels  <convert> umgewandelt, und das      |
  35.  | Ergebnis wird <ziel> zugewiesen. Kann <ziel> nicht den gesamten String  |
  36.  | aufnehmen, wird nur bis zum Ende von <ziel> zugewiesen und <vollst> auf |
  37.  | FALSE gesetzt.                                                          |
  38.  | Als Konvertierungsfunktion eignen sich zum Beispiel die Prozeduren aus  |
  39.  | "Char" ( "LowerCaseGerman","LowerCaseASCIIGerman","CAPGerman",          |
  40.  | "CAPGermanASCII","ToAtariGerman","ToASCIIGerman" ).                     |
  41.   -------------------------------------------------------------------------*)
  42.  
  43.  
  44.  PROCEDURE  EqualConvStr ((* EIN/ -- *) string1,
  45.                           (* EIN/ -- *) string2 : ARRAY OF CHAR;
  46.                           (* EIN/ -- *) convert : CharConvert    ): BOOLEAN;
  47.  
  48. (*-------------------------------------------------------------------------
  49.  | Die mittels <convert> umgewandelten Strings werden zeichenweise mitein- |
  50.  | ander verglichen; die Endebedingung spielt keine Rolle ( siehe "Equal"  |
  51.  | in "Strings" ). Als Konvertierungsfunktion koennen die Prozeduren aus   |
  52.  | "Chars" benutzt werden.                                                 |
  53.   -------------------------------------------------------------------------*)
  54.  
  55.  
  56.  PROCEDURE  CompareCAPStr ((* EIN/ -- *) string1,
  57.                            (* EIN/ -- *) string2:ARRAY OF CHAR ):CompareResult;
  58.  
  59. (*---------------------------------------------------------------------------
  60.  | Vergleicht <string1> und <string2> zeichenweise miteinander; es wird      |
  61.  | nicht zwischen Gross- und Kleinschreibung unterschieden.                  |
  62.  |                                                                           |
  63.  | Das Ergebnis wird folgendermassen gebildet ( lexikographische Ordnung ):  |
  64.  |  - Beim ersten Zeichen von <string1>, das kleiner (groesser) als das ent- |
  65.  |    sprechende Zeichen bei <string2> ist, wird <Less> (<Greater>) zurueck- |
  66.  |    geliefert.                                                             |
  67.  |  - Sind beide Strings gleichlang ( Endekennung spielt keine Rolle !! ),   |
  68.  |    und stimmen die Zeichen bis zum Ende ueberein, wird 'equal' zurueckge- |
  69.  |    liefert.                                                               |
  70.  |  - Ist <string1> kuerzer (laenger) als <string2> und stimmen bis zur      |
  71.  |    Laenge von <string1> alle Zeichen ueberein, wird 'less' ('greater')    |
  72.  |    zurueckgeliefert.                                                      |
  73.   ---------------------------------------------------------------------------*)
  74.  
  75.  
  76.  
  77.  PROCEDURE  LeftPosConvStr  ((* EIN/ -- *) muster  : ARRAY OF CHAR;
  78.                              (* EIN/ -- *) start   : CARDINAL;
  79.                              (* EIN/ -- *) string  : ARRAY OF CHAR;
  80.                              (* EIN/ -- *) convert : CharConvert;
  81.                              (* EIN/ -- *) links   : BOOLEAN       ): CARDINAL;
  82.  
  83.  PROCEDURE  RightPosConvStr ((* EIN/ -- *) muster  : ARRAY OF CHAR;
  84.                              (* EIN/ -- *) start   : CARDINAL;
  85.                              (* EIN/ -- *) string  : ARRAY OF CHAR;
  86.                              (* EIN/ -- *) convert : CharConvert;
  87.                              (* EIN/ -- *) links   : BOOLEAN       ): CARDINAL;
  88.  
  89. (*---------------------------------------------------------------------------
  90.  | Die Prozeduren suchen ab dem <start>-ten Zeichen zum Ende (Anfang) von    |
  91.  | <string> hin nach dem ersten Auftreten von <muster> in <string>.          |
  92.  | Sowohl <string> als auch <muster> werden zuvor zeichenweise mittels       |
  93.  | <convert> in die gewuenschte Darstellung umgewandelt ( z.B. Grossschrei-  |
  94.  | bung unter Beruecksichtigung deutscher Umlaute ).                         |
  95.  | Zurueckgegeben wird die Position des ersten Zeichens von <muster> in      |
  96.  | <string> oder Null, falls <muster> nicht oder nicht vollstaendig in       |
  97.  | <string> auftritt.                                                        |
  98.  |                                                                           |
  99.  |  - Mit <links> laesst sich bestimmen, ob die Position des Musters vom     |
  100.  |    Anfang oder vom Ende von <string> gerechnet wird. Beispiel:            |
  101.  |      <string> = 'abcdefg', <muster> = 'bc',                               |
  102.  |    Falls <links> = TRUE, liefert LeftPos 2, sonst 6.                      |
  103.  |    Dadurch lassen sich auf einfache Weise "LeftString" und "RightString"  |
  104.  |    benutzen.                                                              |
  105.  |  - <start> = 0: Bei "LeftPos"  <=> <start> = 1,                           |
  106.  |    bei "RightPos" <=> <start> = Length( quelle ) - Length( muster ) + 1,  |
  107.  |    d.h. es wird soweit rechts wie moeglich mit der Suche begonnen.        |
  108.  |  - Liegt <start> ausserhalb von <string>, oder ist <muster> ein Leer-     |
  109.  |    string, wird Null zurueckgegeben. Bei "RightPos" wird ein ausserhalb   |
  110.  |    des Strings liegendes <start> wie <start> = 0 behandelt.               |
  111.   ---------------------------------------------------------------------------*)
  112.  
  113.  
  114.  
  115.  PROCEDURE  LeftPosInSet     ((* EIN/ -- *) charSet: ARRAY OF CHAR;
  116.                               (* EIN/ -- *) start  : CARDINAL;
  117.                               (* EIN/ -- *) string : ARRAY OF CHAR;
  118.                               (* EIN/ -- *) links  : BOOLEAN       ):CARDINAL;
  119.  
  120.  PROCEDURE  LeftPosNotInSet  ((* EIN/ -- *) charSet: ARRAY OF CHAR;
  121.                               (* EIN/ -- *) start  : CARDINAL;
  122.                               (* EIN/ -- *) string : ARRAY OF CHAR;
  123.                               (* EIN/ -- *) links  : BOOLEAN       ):CARDINAL;
  124.  
  125.  PROCEDURE  RightPosInSet    ((* EIN/ -- *) charSet: ARRAY OF CHAR;
  126.                               (* EIN/ -- *) start  : CARDINAL;
  127.                               (* EIN/ -- *) string : ARRAY OF CHAR;
  128.                               (* EIN/ -- *) links  : BOOLEAN       ):CARDINAL;
  129.  
  130.  PROCEDURE  RightPosNotInSet ((* EIN/ -- *) charSet: ARRAY OF CHAR;
  131.                               (* EIN/ -- *) start  : CARDINAL;
  132.                               (* EIN/ -- *) string : ARRAY OF CHAR;
  133.                               (* EIN/ -- *) links  : BOOLEAN       ):CARDINAL;
  134.  
  135. (*---------------------------------------------------------------------------
  136.  | Die Prozeduren suchen ab dem <start>-ten Zeichen zum Ende ( Anfang ) von  |
  137.  | <string> hin nach einem Zeichen von <string>, dass ( nicht ) in <charSet> |
  138.  | auftritt. Zurueckgegeben wird die Position dieses Zeichens oder Null,     |
  139.  | falls kein ( nur ) Zeichen aus <charSet> in <string> auftritt (auftreten).|
  140.  |                                                                           |
  141.  |  - Randbedingungen wie bei "Left/RightPosConvStr"                         |
  142.   ---------------------------------------------------------------------------*)
  143.  
  144.  
  145.  PROCEDURE  LeftPosInClass    ((* EIN/ -- *) inClass: CharClassTest;
  146.                                (* EIN/ -- *) start  : CARDINAL;
  147.                                (* EIN/ -- *) string : ARRAY OF CHAR;
  148.                                (* EIN/ -- *) links  : BOOLEAN       ):CARDINAL;
  149.  
  150.  PROCEDURE  LeftPosNotInClass ((* EIN/ -- *) inClass: CharClassTest;
  151.                                (* EIN/ -- *) start  : CARDINAL;
  152.                                (* EIN/ -- *) string : ARRAY OF CHAR;
  153.                                (* EIN/ -- *) links  : BOOLEAN       ):CARDINAL;
  154.  
  155.  PROCEDURE  RightPosInClass   ((* EIN/ -- *) inClass: CharClassTest;
  156.                                (* EIN/ -- *) start  : CARDINAL;
  157.                                (* EIN/ -- *) string : ARRAY OF CHAR;
  158.                                (* EIN/ -- *) links  : BOOLEAN       ):CARDINAL;
  159.  
  160.  PROCEDURE  RightPosNotInClass((* EIN/ -- *) inClass: CharClassTest;
  161.                                (* EIN/ -- *) start  : CARDINAL;
  162.                                (* EIN/ -- *) string : ARRAY OF CHAR;
  163.                                (* EIN/ -- *) links  : BOOLEAN       ):CARDINAL;
  164.  
  165. (*---------------------------------------------------------------------------
  166.  | Die Prozeduren suchen ab dem <start>-ten Zeichen zum Ende ( Anfang ) von  |
  167.  | <string> hin nach einem Zeichen von <string>, dass ( nicht ) in die Klasse|
  168.  | von Zeichen gehoert, die durch <inClass> geprueft wird.                   |
  169.  | Zurueckgegeben wird die Position dieses Zeichens oder Null, falls kein    |
  170.  | ( alle ) Zeichen von <string> in diese Klasse gehoert ( gehoeren ).       |
  171.  |                                                                           |
  172.  |  - Randbedingungen wie bei "Left/RightPosConvStr"                         |
  173.   ---------------------------------------------------------------------------*)
  174.  
  175.  
  176.  
  177.  PROCEDURE  TrimLeft  ((* EIN/AUS *) VAR string : ARRAY OF CHAR );
  178.  
  179.  PROCEDURE  TrimRight ((* EIN/AUS *) VAR string : ARRAY OF CHAR );
  180.  
  181.  PROCEDURE  TrimStr   ((* EIN/AUS *) VAR string : ARRAY OF CHAR );
  182.  
  183. (*---------------------------------------------------------------------------
  184.  | Entfernt alle fuehrenden und/oder abschliessenden Leerzeichen von <string>|
  185.   ---------------------------------------------------------------------------*)
  186.  
  187. END  XStrings.
  188.